//
// Copyright 2021 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only
//

import CryptoKit
import Foundation

// AvatarBuilder has responsibility for building and caching contact and group avatars.
//
// It ensure that avatars update to reflect changes to any state that can affect avatars.
// In some cases this is ensured via cache evacuation, in other cases it is ensured
// by using cache keys that will change if the content changes.
//
// It internally DRYs up handling of:
//
// * Light/dark theme.
// * Avatar blurring.
// * Scaling avatar to reflect view size (honoring pixels vs. points).
// * Changes to avatar colors.
// * LocalUserDisplayMode (should local user appear as "note to self" or as a user?).
//
// Internally AvatarBuilder uses two caches / two types of cache keys:
//
// * Requests: the type of avatar that a view is trying to display, e.g.
//   a contact avatar for user X.
// * Content: the specific content that is used to build an avatar image, e.g.
//   a profile image for user X, a "contact avatar" from system contacts for
//   user X, a default avatar using the initials Y for user X.
//
// Avatars are expensive to build.  By caching requests / content separately,
// we can avoid building avatars unnecessarily while ensuring that avatars
// update correctly without worrying about cache evacuation.

public class AvatarBuilder {

    public static var shared: AvatarBuilder { SSKEnvironment.shared.avatarBuilderRef }

    public static let smallAvatarSizePoints: UInt = 36
    public static let standardAvatarSizePoints: UInt = 48
    public static let mediumAvatarSizePoints: UInt = 68
    public static let largeAvatarSizePoints: UInt = 96

    public static var smallAvatarSizePixels: CGFloat { CGFloat(smallAvatarSizePoints).pointsAsPixels }
    public static var standardAvatarSizePixels: CGFloat { CGFloat(standardAvatarSizePoints).pointsAsPixels }
    public static var mediumAvatarSizePixels: CGFloat { CGFloat(mediumAvatarSizePoints).pointsAsPixels }
    public static var largeAvatarSizePixels: CGFloat { CGFloat(largeAvatarSizePoints).pointsAsPixels }

    // MARK: -

    public init(appReadiness: AppReadiness) {
        SwiftSingletons.register(self)

        appReadiness.runNowOrWhenAppWillBecomeReady {
            self.addObservers()
        }
    }

    // MARK: - Notifications

    private func addObservers() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(otherUsersProfileDidChange(notification:)),
            name: UserProfileNotifications.otherUsersProfileDidChange,
            object: nil
        )
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contactsDidChange(notification:)),
            name: .OWSContactsManagerContactsDidChange,
            object: nil
        )
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(localUsersProfileDidChange(notification:)),
            name: UserProfileNotifications.localProfileDidChange,
            object: nil
        )
    }

    @objc
    private func contactsDidChange(notification: Notification) {
        AssertIsOnMainThread()
        requestToContentCache.removeAllObjects()
    }

    @objc
    private func otherUsersProfileDidChange(notification: Notification) {
        AssertIsOnMainThread()
        if let address = notification.userInfo?[UserProfileNotifications.profileAddressKey] as? SignalServiceAddress {
            addressToAvatarIdentifierCache.removeObject(forKey: address)
        }
    }

    @objc
    private func localUsersProfileDidChange(notification: Notification) {
        AssertIsOnMainThread()
        if let address = DependenciesBridge.shared.tsAccountManager.localIdentifiersWithMaybeSneakyTransaction?.aciAddress {
            addressToAvatarIdentifierCache.removeObject(forKey: address)
        }
    }

    // MARK: -

    public func avatarImage(
        forThread thread: TSThread,
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        return avatarImage(
            forThread: thread,
            diameterPixels: CGFloat(diameterPoints).pointsAsPixels,
            localUserDisplayMode: localUserDisplayMode,
            transaction: transaction
        )
    }

    public func avatarImage(
        forThread thread: TSThread,
        diameterPixels: CGFloat,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        guard let request = buildRequest(
            forThread: thread,
            diameterPixels: diameterPixels,
            localUserDisplayMode: localUserDisplayMode,
            transaction: transaction
        ) else {
            return nil
        }
        return avatarImage(forRequest: request, transaction: transaction)
    }

    public func avatarImageWithSneakyTransaction(
        forAddress address: SignalServiceAddress,
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode
    ) -> UIImage? {
        SSKEnvironment.shared.databaseStorageRef.read { transaction in
            avatarImage(
                forAddress: address,
                diameterPoints: diameterPoints,
                localUserDisplayMode: localUserDisplayMode,
                transaction: transaction
            )
        }
    }

    private func request(
        forAddress address: SignalServiceAddress,
        diameterPixels: CGFloat,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> Request {
        let shouldBlurAvatar = SSKEnvironment.shared.contactManagerImplRef.shouldBlurContactAvatar(address: address, tx: transaction)

        let requestType: RequestType = if shouldBlurAvatar {
            .gradient(AvatarDefaultColorManager.deriveGradient(
                useCase: .contactWithoutRecipient(address: address)
            ))
        } else {
            .contactAddress(address: address, localUserDisplayMode: localUserDisplayMode)
        }

        return Request(requestType: requestType, diameterPixels: diameterPixels)
    }

    public func avatarImage(
        forAddress address: SignalServiceAddress,
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let request = request(
            forAddress: address,
            diameterPixels: CGFloat(diameterPoints).pointsAsPixels,
            localUserDisplayMode: localUserDisplayMode,
            transaction: transaction
        )
        return avatarImage(forRequest: request, transaction: transaction)
    }

    public func avatarImage(
        forAddress address: SignalServiceAddress,
        diameterPixels: CGFloat,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let request = request(
            forAddress: address,
            diameterPixels: diameterPixels,
            localUserDisplayMode: localUserDisplayMode,
            transaction: transaction
        )
        return avatarImage(forRequest: request, transaction: transaction)
    }

    // Never builds; only returns an avatar if there is already a copy
    // in a cache.
    public func precachedAvatarImage(
        forAddress address: SignalServiceAddress,
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let request = request(
            forAddress: address,
            diameterPixels: CGFloat(diameterPoints).pointsAsPixels,
            localUserDisplayMode: localUserDisplayMode,
            transaction: transaction
        )
        guard let requestCacheKey = request.cacheKey else {
            return nil
        }
        guard let content = requestToContentCache.object(forKey: requestCacheKey) else {
            return nil
        }
        return contentToImageCache.object(forKey: content.cacheKey)
    }

    private func request(
        forGroupThread groupThread: TSGroupThread,
        diameterPoints: UInt,
        transaction tx: DBReadTransaction
    ) -> Request {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        let shouldBlurAvatar = SSKEnvironment.shared.contactManagerImplRef.shouldBlurGroupAvatar(
            groupId: groupThread.groupId,
            tx: tx
        )
        let requestType: RequestType = if shouldBlurAvatar {
            .gradient(AvatarDefaultColorManager.deriveGradient(
                useCase: .group(groupId: groupThread.groupId)
            ))
        } else {
            buildRequestType(forGroupThread: groupThread, diameterPixels: diameterPixels, transaction: tx)
        }
        return Request(requestType: requestType, diameterPixels: diameterPixels)
    }

    public func avatarImage(
        forGroupThread groupThread: TSGroupThread,
        diameterPoints: UInt,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let request = request(forGroupThread: groupThread, diameterPoints: diameterPoints, transaction: transaction)
        return avatarImage(forRequest: request, transaction: transaction)
    }

    // Never builds; only returns an avatar if there is already a copy
    // in a cache.
    public func precachedAvatarImage(
        forGroupThread groupThread: TSGroupThread,
        diameterPoints: UInt,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let request = request(forGroupThread: groupThread, diameterPoints: diameterPoints, transaction: transaction)
        guard let requestCacheKey = request.cacheKey else {
            return nil
        }
        guard let content = requestToContentCache.object(forKey: requestCacheKey) else {
            return nil
        }
        return contentToImageCache.object(forKey: content.cacheKey)
    }

    public func avatarImageForLocalUserWithSneakyTransaction(
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode
    ) -> UIImage? {
        SSKEnvironment.shared.databaseStorageRef.read { transaction in
            return avatarImageForLocalUser(
                diameterPoints: diameterPoints,
                localUserDisplayMode: localUserDisplayMode,
                transaction: transaction
            )
        }
    }

    public func avatarImageForLocalUser(
        diameterPoints: UInt,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        guard let address = DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: transaction)?.aciAddress else {
            owsFailDebug("Missing localAddress.")
            return nil
        }
        let requestType: RequestType = .contactAddress(address: address, localUserDisplayMode: localUserDisplayMode)
        let request = Request(requestType: requestType, diameterPixels: diameterPixels)
        return avatarImage(forRequest: request, transaction: transaction)
    }

    public func defaultAvatarImage(
        personNameComponents: PersonNameComponents,
        address: SignalServiceAddress? = nil,
        diameterPoints: UInt,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        let theme: AvatarTheme
        if let address {
            let recipientDatabaseTable = DependenciesBridge.shared.recipientDatabaseTable
            let avatarDefaultColorManager = DependenciesBridge.shared.avatarDefaultColorManager
            if let recipient = recipientDatabaseTable.fetchRecipient(address: address, tx: transaction) {
                theme = avatarDefaultColorManager.defaultColor(useCase: .contact(recipient: recipient), tx: transaction)
            } else {
                theme = avatarDefaultColorManager.defaultColor(useCase: .contactWithoutRecipient(address: address), tx: transaction)
            }
        } else {
            theme = .default
        }
        let requestType: RequestType = {
            if let initials = Self.contactInitials(for: personNameComponents) {
                return .text(text: initials, theme: theme)
            } else {
                return .contactDefaultIcon(theme: theme)
            }
        }()
        let request = Request(requestType: requestType, diameterPixels: diameterPixels)
        return avatarImage(forRequest: request, transaction: transaction)
    }

    public func defaultAvatarImage(
        forGroupId groupId: Data,
        diameterPoints: UInt,
        transaction tx: DBReadTransaction
    ) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        let requestType: RequestType = .groupDefaultIcon(groupId: groupId)
        let request = Request(
            requestType: requestType,
            diameterPixels: CGFloat(diameterPixels)
        )
        let avatarContentType: AvatarContentType = .groupDefault(
            theme: DependenciesBridge.shared.avatarDefaultColorManager
                .defaultColor(useCase: .group(groupId: groupId), tx: tx)
        )
        let avatarContent = AvatarContent(
            request: request,
            contentType: avatarContentType,
            failoverContentType: nil,
            diameterPixels: request.diameterPixels
        )
        return avatarImage(forAvatarContent: avatarContent, transaction: nil)
    }

    public func defaultAvatarImageForLocalUser(
        diameterPoints: UInt,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        return defaultAvatarImageForLocalUser(
            diameterPixels: UInt(diameterPixels),
            transaction: transaction
        )
    }

    public func defaultAvatarImageForLocalUser(
        diameterPixels: UInt,
        transaction: DBReadTransaction
    ) -> UIImage? {
        let requestType: RequestType = {
            let tsAccountManager = DependenciesBridge.shared.tsAccountManager
            let recipientDatabaseTable = DependenciesBridge.shared.recipientDatabaseTable
            let avatarDefaultColorManager = DependenciesBridge.shared.avatarDefaultColorManager

            guard
                let localIdentifiers = tsAccountManager.localIdentifiers(tx: transaction),
                let localRecipient = recipientDatabaseTable.fetchRecipient(serviceId: localIdentifiers.aci, transaction: transaction)
            else {
                return .contactDefaultIcon(theme: .default)
            }

            let theme = avatarDefaultColorManager.defaultColor(useCase: .contact(recipient: localRecipient), tx: transaction)
            let displayName = SSKEnvironment.shared.contactManagerRef.displayName(for: localIdentifiers.aciAddress, tx: transaction)
            if let contactInitials = Self.contactInitials(for: displayName) {
                return .text(text: contactInitials, theme: theme)
            } else {
                return .contactDefaultIcon(theme: theme)
            }
        }()

        let request = Request(
            requestType: requestType,
            diameterPixels: CGFloat(diameterPixels)
        )

        return avatarImage(forRequest: request, transaction: transaction)
    }

    public func avatarImage(model: AvatarModel, diameterPoints: UInt) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        return avatarImage(model: model, diameterPixels: UInt(diameterPixels))
    }

    public func avatarImage(model: AvatarModel, diameterPixels: UInt) -> UIImage? {
        let request = Request(
            requestType: .model(model),
            diameterPixels: CGFloat(diameterPixels)
        )

        let avatarContentType: AvatarContentType
        switch model.type {
        case .icon(let icon):
            avatarContentType = .avatarIcon(icon: icon, theme: model.theme)
        case .image(let url):
            avatarContentType = .file(fileUrl: url, shouldValidate: false)
        case .text(let text):
            avatarContentType = .text(text: text, theme: model.theme)
        }

        let avatarContent = AvatarContent(
            request: request,
            contentType: avatarContentType,
            failoverContentType: nil,
            diameterPixels: request.diameterPixels
        )

        return avatarImage(forAvatarContent: avatarContent, transaction: nil)
    }

    // MARK: - Requests

    // We can't enumerate cache keys to selectively remove certain objects
    // Instead we add a layer of indirection to map known SignalServiceAddress to ephemeral UUID
    // That way, we can index into this indirect cache to remove the ephemeral UUID used to construct
    // the request cacheKey, in effect, removing the item from the final cache.
    private let addressToAvatarIdentifierCache = LRUCache<SignalServiceAddress, String>(maxSize: 256, nseMaxSize: 0)

    public enum RequestType {
        case contactAddress(address: SignalServiceAddress, localUserDisplayMode: LocalUserDisplayMode)
        case text(text: String, theme: AvatarTheme)
        case contactDefaultIcon(theme: AvatarTheme)
        case group(groupId: Data, avatarData: Data, digestString: String)
        case groupDefaultIcon(groupId: Data)
        case model(AvatarModel)
        case gradient(AvatarGradient)

        fileprivate var cacheKey: String {
            switch self {
            case .contactAddress(let address, let localUserDisplayMode):
                let indirectAvatarIdentifier = AvatarBuilder.shared.addressToAvatarIdentifierCache[address] ?? {
                    let newId = UUID().uuidString
                    AvatarBuilder.shared.addressToAvatarIdentifierCache[address] = newId
                    return newId
                }()
                return "contactAddress.\(indirectAvatarIdentifier).\(localUserDisplayMode.rawValue)"
            case .text(let text, let theme):
                return "text.\(text).\(theme.rawValue)"
            case .contactDefaultIcon(let theme):
                return "contactDefaultIcon.\(theme.rawValue)"
            case .group(let groupId, _, let digestString):
                return "group.\(groupId.hexadecimalString).\(digestString)"
            case .groupDefaultIcon(let groupId):
                return "groupDefaultIcon.\(groupId.hexadecimalString)"
            case .model(let avatarModel):
                switch avatarModel.type {
                case .icon(let icon):
                    return "icon.\(icon.rawValue).\(avatarModel.theme.rawValue)"
                case .text(let text):
                    return "text.\(text).\(avatarModel.theme.rawValue)"
                case .image(let url):
                    return "file.\(url.path)"
                }
            case .gradient(let gradient):
                return "gradient.\(gradient.id)"
            }
        }
    }

    public struct Request {
        let requestType: RequestType
        let diameterPixels: CGFloat

        fileprivate var cacheKey: String? {
            "\(requestType.cacheKey).\(diameterPixels)"
        }
    }

    private func buildRequest(
        forThread thread: TSThread,
        diameterPixels: CGFloat,
        localUserDisplayMode: LocalUserDisplayMode,
        transaction: DBReadTransaction
    ) -> Request? {
        func buildRequestType() -> RequestType? {
            if let contactThread = thread as? TSContactThread {
                let shouldBlurAvatar = SSKEnvironment.shared.contactManagerImplRef.shouldBlurContactAvatar(
                    address: contactThread.contactAddress,
                    tx: transaction
                )
                let requestType: RequestType = if shouldBlurAvatar {
                    .gradient(AvatarDefaultColorManager.deriveGradient(
                        useCase: .contactWithoutRecipient(address: contactThread.contactAddress)
                    ))
                } else {
                    .contactAddress(
                        address: contactThread.contactAddress,
                        localUserDisplayMode: localUserDisplayMode
                    )
                }
                return requestType
            } else if let groupThread = thread as? TSGroupThread {
                let shouldBlurAvatar = SSKEnvironment.shared.contactManagerImplRef
                    .shouldBlurGroupAvatar(
                        groupId: groupThread.groupId,
                        tx: transaction
                    )

                let requestType: RequestType = if shouldBlurAvatar {
                    .gradient(AvatarDefaultColorManager.deriveGradient(
                        useCase: .group(groupId: groupThread.groupId)
                    ))
                } else {
                    self.buildRequestType(
                        forGroupThread: groupThread,
                        diameterPixels: diameterPixels,
                        transaction: transaction
                    )
                }
                return requestType
            } else {
                owsFailDebug("Invalid thread.")
                return nil
            }
        }
        guard let requestType = buildRequestType() else {
            return nil
        }
        return Request(requestType: requestType, diameterPixels: diameterPixels)
    }

    private func buildRequestType(
        forGroupThread groupThread: TSGroupThread,
        diameterPixels: CGFloat,
        transaction tx: DBReadTransaction
    ) -> RequestType {
        func requestTypeForGroup(groupThread: TSGroupThread) -> RequestType {
            if let avatarData = groupThread.groupModel.avatarDataState.dataIfPresent {
                let digestString = avatarData.sha1HexadecimalDigestString
                return .group(groupId: groupThread.groupId, avatarData: avatarData, digestString: digestString)
            } else {
                return .groupDefaultIcon(groupId: groupThread.groupId)
            }
        }
        if let latestGroupThread = TSGroupThread.anyFetchGroupThread(uniqueId: groupThread.uniqueId, transaction: tx) {
            return requestTypeForGroup(groupThread: latestGroupThread)
        } else {
            owsFailDebug("Missing groupThread.")
            return requestTypeForGroup(groupThread: groupThread)
        }
    }

    // MARK: -

    private static func contactInitials(for displayName: DisplayName) -> String? {
        let nameComponents: PersonNameComponents

        switch displayName {
        case .nickname(let nickname):
            nameComponents = nickname.nameComponents
        case .systemContactName(let systemContactName):
            nameComponents = systemContactName.nameComponents
        case .profileName(let profileNameComponents):
            nameComponents = profileNameComponents
        case .phoneNumber, .username, .deletedAccount, .unknown:
            return nil
        }

        return contactInitials(for: nameComponents)
    }

    private static func contactInitials(for nameComponents: PersonNameComponents) -> String? {
        let formattedAbbreviation = OWSFormat.formatNameComponents(nameComponents, style: .abbreviated)
        guard let formattedAbbreviation = formattedAbbreviation.filterForDisplay.nilIfEmpty else {
            Logger.warn("Could not abbreviate name.")
            return nil
        }
        // Some languages, such as Arabic, don't natively support abbreviations or
        // have default abbreviations that are too long. In this case, we will not
        // show an abbreviation. This matches the behavior of iMessage.
        guard formattedAbbreviation.count < 4 else {
            return nil
        }
        return formattedAbbreviation
    }

    // MARK: - Content

    private enum AvatarContentType: Equatable {
        case file(fileUrl: URL, shouldValidate: Bool)
        case data(imageData: Data, digestString: String, shouldValidate: Bool)
        case text(text: String, theme: AvatarTheme)
        case tintedImage(name: String, theme: AvatarTheme)
        case avatarIcon(icon: AvatarIcon, theme: AvatarTheme)
        case cachedContact(address: SignalServiceAddress, cacheKey: String)
        case gradient(AvatarGradient)

        static func noteToSelf(theme: AvatarTheme) -> Self {
            return .tintedImage(
                // The way we render avatars doesn't respect the asset catalog's
                // icon direction, so the RTL variant needs to be specified
                // here, but other uses of "note-resizable" automatically flip.
                name: CurrentAppContext().isRTL ? "note-rtl" : "note-resizable",
                theme: theme
            )
        }

        static func groupDefault(theme: AvatarTheme) -> Self {
            return .tintedImage(name: "group-resizable", theme: theme)
        }

        static func contactDefaultIcon(theme: AvatarTheme) -> Self {
            return .tintedImage(name: "person-resizable", theme: theme)
        }

        fileprivate var cacheKey: String {
            switch self {
            case .file(let fileUrl, _):
                return "file.\(fileUrl.path)"
            case .data(_, let digestString, _):
                return "data.\(digestString)"
            case .text(let text, let theme):
                return "text.\(text).\(theme.rawValue)"
            case .tintedImage(let name, let theme):
                return "tintedImage.\(name).\(theme.rawValue)"
            case .avatarIcon(let icon, let theme):
                return "avatarIcon.\(icon.rawValue).\(theme.rawValue)"
            case .cachedContact(_, let cacheKey):
                return cacheKey
            case .gradient(let gradient):
                return "gradient.\(gradient.id)"
            }
        }
    }

    private class AvatarContent: NSObject {
        // We track the first request used to build this content for debugging purposes.
        let request: Request

        let contentType: AvatarContentType
        let failoverContentType: AvatarContentType?
        let diameterPixels: CGFloat

        init(
            request: Request,
            contentType: AvatarContentType,
            failoverContentType: AvatarContentType?,
            diameterPixels: CGFloat
        ) {
            self.request = request
            self.contentType = contentType
            self.failoverContentType = failoverContentType
            self.diameterPixels = diameterPixels
        }

        fileprivate var cacheKey: String {
            // We used to blur avatar images from message requests (now we
            // prevent the download in the first place). This "false" at
            // the end indicates the normal, unblurred avatar.
            "\(contentType.cacheKey).\(diameterPixels).\(false)"
        }
    }

    // MARK: -

    private func avatarImage(forRequest request: Request, transaction: DBReadTransaction) -> UIImage? {
        let avatarContent = avatarContent(forRequest: request, transaction: transaction)
        return avatarImage(forAvatarContent: avatarContent, transaction: transaction)
    }

    // This cache needs to be evacuated whenever anything that
    // would affect AvatarContent for the request changes.
    private let requestToContentCache = LRUCache<String, AvatarContent>(maxSize: 128, nseMaxSize: 0)

    private func avatarContent(forRequest request: Request, transaction: DBReadTransaction) -> AvatarContent {
        if let cacheKey = request.cacheKey, let avatarContent = requestToContentCache.object(forKey: cacheKey) {
            return avatarContent
        }

        let avatarContent = buildAvatarContent(forRequest: request, transaction: transaction)

        if let cacheKey = request.cacheKey {
            requestToContentCache.setObject(avatarContent, forKey: cacheKey)
        }
        return avatarContent
    }

    // This cache never needs to be evacuated. The cache keys will change
    // whenever state in the content changes that would affect the image.
    private let contentToImageCache = LRUCache<String, UIImage>(maxSize: 128, nseMaxSize: 0)
    public static let avatarCacheDirectory = URL(
        fileURLWithPath: "Library/Caches/AvatarBuilder",
        isDirectory: true,
        relativeTo: URL(
            fileURLWithPath: CurrentAppContext().appSharedDataDirectoryPath(),
            isDirectory: true
        )
    )

    private static let contactCacheKeys = KeyValueStore(collection: "AvatarBuilder.contactCacheKeys")

    private func avatarImage(forAvatarContent avatarContent: AvatarContent, transaction: DBReadTransaction?) -> UIImage? {
        let cacheKey = avatarContent.cacheKey

        if let image = contentToImageCache.object(forKey: cacheKey) {
            return image
        }

        func saveCacheKeyForNSE() {
            if
                case .contactAddress(address: let address, localUserDisplayMode: _) = avatarContent.request.requestType,
                let serviceIdString = address.serviceIdUppercaseString,
                let transaction = transaction
            {
                let contentCacheKey = avatarContent.contentType.cacheKey
                if contentCacheKey != Self.contactCacheKeys.getString(serviceIdString, transaction: transaction) {
                    SSKEnvironment.shared.databaseStorageRef.asyncWrite { writeTransaction in
                        Self.contactCacheKeys.setString(contentCacheKey, key: serviceIdString, transaction: writeTransaction)
                    }
                }
            }
        }

        // We use the digest of the cache key for the filename, to ensure it's safe
        // for use in the filename (it's a hexadecimal string so only 0-9a-f).
        let cachedImageUrl = URL(fileURLWithPath: cacheKey.sha1HexadecimalDigestString + ".png", relativeTo: Self.avatarCacheDirectory)

        if let image = UIImage(contentsOfFile: cachedImageUrl.path) {
            memoryCacheAvatarImageIfEligible(image, cacheKey: cacheKey)
            saveCacheKeyForNSE()
            return image
        }

        // We never build avatars in the NSE, as it's a very expensive operation.
        guard !CurrentAppContext().isNSE else { return nil }

        guard let image = Self.buildOrLoadImage(forAvatarContent: avatarContent, transaction: transaction) else {
            return nil
        }

        memoryCacheAvatarImageIfEligible(image, cacheKey: cacheKey)
        saveCacheKeyForNSE()

        // Always cache the avatar image to disk.
        OWSFileSystem.ensureDirectoryExists(Self.avatarCacheDirectory.path)

        if let pngData = image.pngData() {
            do {
                try pngData.write(to: cachedImageUrl)
            } catch {
                owsFailDebug("Failed to cache avatar image to disk \(error)")
            }
        } else {
            owsFailDebug("Failed to determine png data for avatar")
        }

        return image
    }

    private func memoryCacheAvatarImageIfEligible(_ image: UIImage, cacheKey: String) {
        // The avatars in our hot code paths which are 36-56pt.  At 3x scale,
        // a threshold of 200 will include these avatars.
        let maxCacheSizePixels = 200
        let canCacheAvatarImage: Bool = (
            image.pixelWidth <= maxCacheSizePixels
            && image.pixelHeight <= maxCacheSizePixels
        )
        guard canCacheAvatarImage else { return }
        contentToImageCache.setObject(image, forKey: cacheKey)
    }

    // MARK: - Building Content

    private func buildAvatarContent(forRequest request: Request,
                                    transaction: DBReadTransaction) -> AvatarContent {
        struct AvatarContentTypes {
            let contentType: AvatarContentType
            let failoverContentType: AvatarContentType?
        }
        func buildAvatarContentTypes() -> AvatarContentTypes {
            switch request.requestType {
            case .contactAddress(let address, let localUserDisplayMode):
                guard address.isValid else {
                    owsFailDebug("Invalid address.")
                    return AvatarContentTypes(contentType: .contactDefaultIcon(theme: .default), failoverContentType: nil)
                }

                let recipientDatabaseTable = DependenciesBridge.shared.recipientDatabaseTable
                let avatarDefaultColorManager = DependenciesBridge.shared.avatarDefaultColorManager
                let theme: AvatarTheme
                if let recipient = recipientDatabaseTable.fetchRecipient(address: address, tx: transaction) {
                    theme = avatarDefaultColorManager.defaultColor(useCase: .contact(recipient: recipient), tx: transaction)
                } else {
                    theme = avatarDefaultColorManager.defaultColor(useCase: .contactWithoutRecipient(address: address), tx: transaction)
                }

                if address.isLocalAddress, localUserDisplayMode == .noteToSelf {
                    return AvatarContentTypes(
                        contentType: .noteToSelf(theme: theme),
                        failoverContentType: .contactDefaultIcon(theme: theme)
                    )
                }

                if CurrentAppContext().isNSE {
                    // We don't jump to using cached data outside the NSE because we don't want to use an *old* avatar
                    // for someone who's updated theirs. (This is the code path where we discover it's been updated!)
                    if
                        let serviceIdString = address.serviceIdUppercaseString,
                        let cacheKey = Self.contactCacheKeys.getString(serviceIdString, transaction: transaction)
                    {
                        return AvatarContentTypes(
                            contentType: .cachedContact(address: address, cacheKey: cacheKey),
                            failoverContentType: .contactDefaultIcon(theme: theme)
                        )
                    }
                } else {
                    let imageData = SSKEnvironment.shared.contactManagerImplRef.avatarImageData(forAddress: address, transaction: transaction)
                    if let imageData {
                        let digestString = imageData.sha1HexadecimalDigestString
                        return AvatarContentTypes(
                            contentType: .data(imageData: imageData, digestString: digestString, shouldValidate: false),
                            failoverContentType: .contactDefaultIcon(theme: theme)
                        )
                    }

                    let displayName = SSKEnvironment.shared.contactManagerRef.displayName(for: address, tx: transaction)
                    if let contactInitials = Self.contactInitials(for: displayName) {
                        return AvatarContentTypes(
                            contentType: .text(text: contactInitials, theme: theme),
                            failoverContentType: .contactDefaultIcon(theme: theme)
                        )
                    }
                }
                return AvatarContentTypes(contentType: .contactDefaultIcon(theme: theme), failoverContentType: nil)
            case .text(let text, let theme):
                return AvatarContentTypes(
                    contentType: .text(text: text, theme: theme),
                    failoverContentType: .contactDefaultIcon(theme: theme)
                )
            case .contactDefaultIcon(let theme):
                return AvatarContentTypes(
                    contentType: .contactDefaultIcon(theme: theme),
                    failoverContentType: nil
                )
            case .group(let groupId, let avatarData, let digestString):
                let theme = DependenciesBridge.shared.avatarDefaultColorManager
                    .defaultColor(useCase: .group(groupId: groupId), tx: transaction)
                return AvatarContentTypes(
                    contentType: .data(imageData: avatarData, digestString: digestString, shouldValidate: false),
                    failoverContentType: .groupDefault(theme: theme)
                )
            case .groupDefaultIcon(let groupId):
                let theme = DependenciesBridge.shared.avatarDefaultColorManager
                    .defaultColor(useCase: .group(groupId: groupId), tx: transaction)
                return AvatarContentTypes(contentType: .groupDefault(theme: theme), failoverContentType: nil)
            case .model(let model):
                switch model.type {
                case .icon(let icon):
                    return AvatarContentTypes(
                        contentType: .avatarIcon(icon: icon, theme: model.theme),
                        failoverContentType: nil
                    )
                case .image(let url):
                    return AvatarContentTypes(
                        contentType: .file(fileUrl: url, shouldValidate: false),
                        failoverContentType: nil
                    )
                case .text(let text):
                    return AvatarContentTypes(
                        contentType: .text(text: text, theme: model.theme),
                        failoverContentType: nil
                    )
                }
            case .gradient(let gradient):
                return AvatarContentTypes(
                    contentType: .gradient(gradient),
                    failoverContentType: nil
                )
            }
        }
        let contentTypes = buildAvatarContentTypes()
        return AvatarContent(
            request: request,
            contentType: contentTypes.contentType,
            failoverContentType: contentTypes.failoverContentType,
            diameterPixels: request.diameterPixels
        )
    }

    // MARK: - Building Images

    // TODO: We could modify this method to always return some kind of
    //       default avatar.
    private static func buildOrLoadImage(
        forAvatarContent avatarContent: AvatarContent,
        transaction: DBReadTransaction?
    ) -> UIImage? {
        func buildOrLoadWithContentType(_ contentType: AvatarContentType) -> UIImage? {
            switch contentType {
            case .file(let fileUrl, let shouldValidate):
                return loadAndResizeAvatarFile(
                    avatarContent: avatarContent,
                    fileUrl: fileUrl,
                    shouldValidate: shouldValidate
                )
            case .data(let imageData, _, let shouldValidate):
                return loadAndResizeAvatarImageData(
                    avatarContent: avatarContent,
                    imageData: imageData,
                    shouldValidate: shouldValidate
                )
            case .cachedContact(let contactAddress, _):
                guard let transaction = transaction else {
                    owsFailDebug("tried to build a contact avatar without a transaction")
                    return nil
                }
                guard let imageData = SSKEnvironment.shared.contactManagerImplRef.avatarImageData(
                    forAddress: contactAddress,
                    transaction: transaction
                ) else {
                    return nil
                }
                return loadAndResizeAvatarImageData(
                    avatarContent: avatarContent,
                    imageData: imageData,
                    shouldValidate: false
                )
            case .text(let text, let theme):
                return buildAvatar(avatarContent: avatarContent, text: text, theme: theme)
            case .tintedImage(let name, let theme):
                return buildAvatar(avatarContent: avatarContent, tintedImageName: name, theme: theme)
            case .avatarIcon(let icon, let theme):
                return buildAvatar(avatarContent: avatarContent, avatarIcon: icon, theme: theme)
            case .gradient(let gradient):
                return buildAvatar(diameterPixels: avatarContent.diameterPixels, gradient: gradient)
            }
        }
        func buildOrLoad() -> UIImage? {
            if let image = buildOrLoadWithContentType(avatarContent.contentType) {
                return image
            }
            if
                let failoverContentType = avatarContent.failoverContentType,
                let image = buildOrLoadWithContentType(failoverContentType)
            {
                return image
            }
            owsFailDebug("Could not build avatar.")
            return nil
        }
        // Ensure image scale matches main screen scale.
        guard let image = normalizeImageScale(buildOrLoad()) else {
            return nil
        }

        // Output should always be square.
        owsAssertDebug(image.pixelWidth == image.pixelHeight)
        // Output should always be target size or smaller.
        owsAssertDebug(CGFloat(image.pixelWidth) <= avatarContent.diameterPixels)
        owsAssertDebug(CGFloat(image.pixelHeight) <= avatarContent.diameterPixels)

        return image
    }

    // Ensure image scale matches main screen scale.
    private static func normalizeImageScale(_ image: UIImage?) -> UIImage? {
        guard let image = image, let cgImage = image.cgImage else {
            owsFailDebug("Missing or invalid image.")
            return nil
        }
        if image.scale == UIScreen.main.scale {
            return image
        } else {
            return UIImage(cgImage: cgImage, scale: UIScreen.main.scale, orientation: image.imageOrientation)
        }
    }

    private static func loadAndResizeAvatarFile(
        avatarContent: AvatarContent,
        fileUrl: URL,
        shouldValidate: Bool
    ) -> UIImage? {
        let diameterPixels = avatarContent.diameterPixels
        if shouldValidate {
            guard (try? DataImageSource.forPath(fileUrl.path))?.ows_isValidImage ?? false else {
                owsFailDebug("Invalid image.")
                return nil
            }
        }
        guard let sourceImage = UIImage(contentsOfFile: fileUrl.path) else {
            owsFailDebug("Missing or invalid sourceImage.")
            return nil
        }
        let pixelWidth = sourceImage.pixelWidth
        let pixelHeight = sourceImage.pixelHeight
        if CGFloat(pixelWidth) > diameterPixels || CGFloat(pixelHeight) > diameterPixels {
            // Resize to target size.
            return sourceImage.resizedImage(toFillPixelSize: .square(diameterPixels))
        }
        if pixelWidth != pixelHeight {
            // Crop to square.
            let pixelSize = min(pixelWidth, pixelHeight)
            return sourceImage.resizedImage(toFillPixelSize: .square(CGFloat(pixelSize)))
        }
        return sourceImage
    }

    private static func loadAndResizeAvatarImageData(
        avatarContent: AvatarContent,
        imageData: Data,
        shouldValidate: Bool
    ) -> UIImage? {
        let diameterPixels = avatarContent.diameterPixels
        if shouldValidate {
            guard DataImageSource(imageData).ows_isValidImage else {
                owsFailDebug("Invalid imageData.")
                return nil
            }
        }
        guard let sourceImage = UIImage(data: imageData) else {
            owsFailDebug("Missing or invalid sourceImage.")
            return nil
        }
        let pixelWidth = sourceImage.pixelWidth
        let pixelHeight = sourceImage.pixelHeight
        if CGFloat(pixelWidth) > diameterPixels || CGFloat(pixelHeight) > diameterPixels {
            // Resize to target size.
            return sourceImage.resizedImage(toFillPixelSize: .square(diameterPixels))
        }
        if pixelWidth != pixelHeight {
            // Crop to square.
            let pixelSize = min(pixelWidth, pixelHeight)
            return sourceImage.resizedImage(toFillPixelSize: .square(CGFloat(pixelSize)))
        }
        return sourceImage
    }

    private static func buildAvatar(
        avatarContent: AvatarContent,
        text: String,
        theme: AvatarTheme
    ) -> UIImage? {
        let diameterPixels = avatarContent.diameterPixels
        return buildAvatar(
            text: text,
            textColor: theme.foregroundColor,
            backgroundColor: theme.backgroundColor,
            diameterPixels: diameterPixels
        )
    }

    private static func buildAvatar(
        avatarContent: AvatarContent,
        tintedImageName: String,
        theme: AvatarTheme
    ) -> UIImage? {
        guard let image = UIImage(named: tintedImageName) else {
            owsFailDebug("Missing icon with name \(tintedImageName)")
            return nil
        }

        let diameterPixels = avatarContent.diameterPixels

        let margin = avatarImageMargins(diameter: diameterPixels)
        let totalIconDiamterPixels = diameterPixels - margin.totalWidth

        return buildAvatar(
            diameterPixels: diameterPixels,
            backgroundColor: theme.backgroundColor
        ) { context in
            drawIconInAvatar(
                icon: image,
                iconSizePixels: CGSize(square: totalIconDiamterPixels),
                iconColor: theme.foregroundColor,
                diameterPixels: diameterPixels,
                context: context
            )
        }
    }

    private static func buildAvatar(
        avatarContent: AvatarContent,
        avatarIcon: AvatarIcon,
        theme: AvatarTheme
    ) -> UIImage? {
        let diameterPixels = avatarContent.diameterPixels

        return buildAvatar(
            diameterPixels: diameterPixels,
            backgroundColor: theme.backgroundColor
        ) { context in
            drawIconInAvatar(
                icon: avatarIcon.image,
                iconSizePixels: CGSize(square: diameterPixels),
                diameterPixels: diameterPixels,
                context: context
            )
        }
    }

    private static func buildAvatar(
        text: String,
        textColor: UIColor,
        backgroundColor: UIColor,
        diameterPixels: CGFloat
    ) -> UIImage? {
        return buildAvatar(
            diameterPixels: diameterPixels,
            backgroundColor: backgroundColor
        ) { context in
            drawTextInAvatar(
                text: text,
                textColor: textColor,
                diameterPixels: diameterPixels,
                context: context
            )
        }
    }

    private static func buildAvatar(
        diameterPixels: CGFloat,
        gradient: AvatarGradient
    ) -> UIImage? {
        guard diameterPixels > 0 else {
            owsFailDebug("Invalid diameter.")
            return nil
        }

        let frame = CGRect(origin: .zero, size: .square(diameterPixels))

        let format = UIGraphicsImageRendererFormat()
        format.scale = 1
        let image = UIGraphicsImageRenderer(size: frame.size, format: format).image { context in
            let layer = CAGradientLayer()
            layer.frame = frame
            layer.colors = [gradient.topColor.cgColor, gradient.bottomColor.cgColor]
            layer.startPoint = CGPoint(x: 0.5, y: 0.0)
            layer.endPoint = CGPoint(x: 0.5, y: 1.0)
            layer.render(in: context.cgContext)
        }

        return normalizeImageScale(image)
    }

    private static func buildAvatar(
        diameterPixels: CGFloat,
        backgroundColor: UIColor,
        drawBlock: (CGContext) -> Void
    ) -> UIImage? {
        let diameterPixels = diameterPixels
        guard diameterPixels > 0 else {
            owsFailDebug("Invalid diameter.")
            return nil
        }

        let frame = CGRect(origin: .zero, size: .square(diameterPixels))

        UIGraphicsBeginImageContextWithOptions(frame.size, false, 1)
        guard let context = UIGraphicsGetCurrentContext() else {
            owsFailDebug("Missing context.")
            return nil
        }
        defer { UIGraphicsEndImageContext() }

        context.setFillColor(backgroundColor.cgColor)
        context.fill(frame)

        context.saveGState()
        drawBlock(context)
        context.restoreGState()

        guard let image = UIGraphicsGetImageFromCurrentImageContext() else {
            owsFailDebug("Missing image.")
            return nil
        }

        return normalizeImageScale(image)
    }

    public static func avatarMaxFont(diameter: CGFloat, isEmojiOnly: Bool) -> UIFont {
        // We use the "Inter" font for text based avatars, so they look
        // the same across all platforms. The font is scaled relative to
        // the height of the avatar. By sizing it to half the dimater, it
        // will always be at least big enough to scale down to fit within
        // the avatar.
        return UIFont(name: "Inter-Regular_Medium", size: diameter * (isEmojiOnly ? 0.6 : 0.45))!
    }

    public static func avatarImageMargins(diameter: CGFloat) -> UIEdgeInsets {
        UIEdgeInsets(margin: diameter * 0.2)
    }

    public static func avatarTextMargins(diameter: CGFloat) -> UIEdgeInsets {
        UIEdgeInsets(margin: diameter * 0.1)
    }

    private static func drawTextInAvatar(
        text: String,
        textColor: UIColor,
        diameterPixels: CGFloat,
        context: CGContext
    ) {
        guard let text = text.strippedOrNil else {
            owsFailDebug("Invalid text.")
            return
        }
        guard diameterPixels > 0 else {
            owsFailDebug("Invalid diameter.")
            return
        }

        let frame = CGRect(origin: .zero, size: .square(diameterPixels))
        let font = avatarMaxFont(diameter: diameterPixels, isEmojiOnly: text.containsOnlyEmoji)
        let margins = avatarTextMargins(diameter: diameterPixels)

        let textAttributesForMeasurement: [NSAttributedString.Key: Any] = [
            .font: font,
            .foregroundColor: textColor
        ]
        let options: NSStringDrawingOptions = [.usesLineFragmentOrigin, .usesFontLeading]
        let baseTextSize = (text).boundingRect(
            with: CGSize(width: .max, height: .max),
            options: options,
            attributes: textAttributesForMeasurement,
            context: nil
        ).size
        // Ensure that the text fits within the avatar bounds, with a margin.
        guard baseTextSize.isNonEmpty else {
            owsFailDebug("Text has invalid bounds.")
            return
        }

        let maxTextDiameterPixels = diameterPixels - margins.totalWidth
        let textSizePixels = baseTextSize.largerAxis
        let scaling = (maxTextDiameterPixels / textSizePixels).clamp01()

        let textAttributesForDrawing: [NSAttributedString.Key: Any] = [
            .font: font.withSize(font.pointSize * scaling),
            .foregroundColor: textColor
        ]
        let textSizeScaled = (text).boundingRect(
            with: frame.size,
            options: options,
            attributes: textAttributesForDrawing,
            context: nil
        ).size
        let locationPixels = (frame.size.asPoint - textSizeScaled.asPoint) * 0.5
        (text).draw(at: locationPixels, withAttributes: textAttributesForDrawing)
    }

    private static func drawIconInAvatar(
        icon: UIImage,
        iconSizePixels: CGSize,
        iconColor: UIColor? = nil,
        diameterPixels: CGFloat,
        context: CGContext
    ) {
        context.saveGState()
        defer { context.restoreGState() }

        guard iconSizePixels.isNonEmpty else {
            owsFailDebug("Invalid iconSize.")
            return
        }
        guard diameterPixels > 0 else {
            owsFailDebug("Invalid diameter.")
            return
        }

        if let iconColor = iconColor {
            // There is a bug with "Preserve Vector Data" when operating
            // on the underlying cgImage rather than drawing the UIImage
            // object directly (as we do in the untinted path below) that
            // results in the image rendering fuzzy when rendered at sizes
            // larger than the original, even though vector data is available.
            // To combat this, we draw the UIImage into a UIImage of the size
            // we actually need before proceeding to create the mask with the
            // underlying cgImage. This ensures a sharp output at a small additional
            // perf cost.
            let resizedImage = icon.resizedImage(toFillPixelSize: iconSizePixels)

            guard let icon = resizedImage.cgImage else {
                owsFailDebug("Invalid icon.")
                return
            }

            // UIKit uses an ULO coordinate system (upper-left-origin).
            // Core Graphics uses an LLO coordinate system (lower-left-origin).
            let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: diameterPixels)
            context.concatenate(flipVertical)

            let diameterSizePixels = CGSize.square(diameterPixels)

            // The programmatic equivalent of UIImageRenderingModeAlwaysTemplate/tintColor.
            context.setBlendMode(.normal)
            let offsetPixels = (diameterSizePixels.asPoint - iconSizePixels.asPoint) * 0.5
            let maskRect = CGRect(origin: offsetPixels, size: iconSizePixels)
            context.clip(to: maskRect, mask: icon)
            context.setFillColor(iconColor.cgColor)
            context.fill(CGRect(origin: .zero, size: diameterSizePixels))
        } else {
            let iconRect = CGRect(
                origin: CGPoint(
                    x: (diameterPixels - iconSizePixels.width) / 2,
                    y: (diameterPixels - iconSizePixels.height) / 2
                ),
                size: iconSizePixels
            )
            icon.draw(in: iconRect)
        }
    }
}

// MARK: -

fileprivate extension Data {
    var sha1HexadecimalDigestString: String {
        Data(Insecure.SHA1.hash(data: self)).hexadecimalString
    }
}

fileprivate extension String {
    var sha1HexadecimalDigestString: String {
        Data(self.utf8).sha1HexadecimalDigestString
    }
}

// MARK: -

#if USE_DEBUG_UI

extension AvatarBuilder {

    public static func buildNoiseAvatar(diameterPoints: UInt) -> UIImage? {
        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels
        let backgroundColor = UIColor(rgbHex: 0xaca6633)
        return Self.buildAvatar(diameterPixels: diameterPixels, backgroundColor: backgroundColor) { context in
            Self.drawNoiseInAvatar(diameterPixels: diameterPixels, context: context)
        }
    }

    private static func drawNoiseInAvatar(diameterPixels: CGFloat, context: CGContext) {
        context.saveGState()
        defer { context.restoreGState() }

        let diameterPixels = UInt(diameterPixels)
        guard diameterPixels > 0 else {
            owsFailDebug("Invalid diameter.")
            return
        }

        let stride: UInt = 1
        var x: UInt = 0
        while x < diameterPixels {
            var y: UInt = 0
            while y < diameterPixels {
                let color = UIColor.ows_randomColor(isAlphaRandom: false)
                context.setFillColor(color.cgColor)
                let rect = CGRect(origin: CGPoint(x: CGFloat(x), y: CGFloat(y)), size: .square(CGFloat(stride)))
                context.fill(rect)
                y += stride
            }
            x += stride
        }
    }

    public static func buildRandomAvatar(diameterPoints: UInt) -> UIImage? {
        let eyes = [ ":", "=", "8", "B" ]
        let mouths = [ "3", ")", "(", "|", "\\", "P", "D", "o" ]
        // eyebrows are rare
        let eyebrows = [ ">", "", "", "", "" ]

        let randomEye = eyes.shuffled().first!
        let randomMouth = mouths.shuffled().first!
        let randomEyebrow = eyebrows.shuffled().first!
        let face = "\(randomEyebrow)\(randomEye)\(randomMouth)"

        let diameterPixels = CGFloat(diameterPoints).pointsAsPixels

        let theme = AvatarTheme.allCases.randomElement()!

        return buildAvatar(
            diameterPixels: diameterPixels,
            backgroundColor: theme.backgroundColor
        ) { context in
            context.translateBy(x: +diameterPixels / 2, y: +diameterPixels / 2)
            context.rotate(by: CGFloat.halfPi)
            context.translateBy(x: -diameterPixels / 2, y: -diameterPixels / 2)
            drawTextInAvatar(
                text: face,
                textColor: theme.foregroundColor,
                diameterPixels: diameterPixels,
                context: context
            )
        }
    }
}

#endif
